The invention generally relates to data processing. The present invention relates more specifically to integrating and executing software modules in an application.
Computer programs or applications may be formed of one or more software modules which mutually depend on each other. The software modules may be developed by different developers who may reside at different sites or work for different companies. The developers must coordinate their development efforts, to ensure that the dependencies of each of the software modules are met, and that the software modules may be integrated to operate together in a working application. The increasing complexity of modern applications often results in an increased quantity of software modules per application and an increased dependency between the software modules.
The term software module, as used herein, refers to computer programs, sections of a program, or data used by computer programs, and is not limited to programs developed in any particular computer language. The term application refers to a set of multiple software modules or programs that cooperate to carry out useful functions. The term application integration refers to the process of integrating software modules into an operable application.
An example of one of many possible dependencies that may exist between the software modules of an application is the use of correct reference names and storage locations for the software modules. The correct reference names and locations are needed so that the modules may be loaded and run correctly by the application. For example, an application xe2x80x9cAPPxe2x80x9d includes a main software module xe2x80x9cMAINxe2x80x9d. MAIN is used to invoke the other software modules (xe2x80x9cAPP modulesxe2x80x9d) that, at least in part, form the application. MAIN includes code which, when executed, loads and runs the APP modules. This code explicitly refers to each APP module. An explicit reference is code or data which is used to either identify a particular module, locate a particular module, or both. For example, MAIN may contain the code xe2x80x9crun moduleAxe2x80x9d. The reference xe2x80x9cmoduleAxe2x80x9d explicitly refers to a particular software module. When code to carry out xe2x80x9crun moduleAxe2x80x9d is executed by MAIN, module A is loaded and then executed. Alternatively, a reference may contain information that explicitly identifies the location of a module to run. For example, the code xe2x80x9cload c:/Programs Files/APP/moduleAxe2x80x9d explicitly identifies the file location of the file containing the code for moduleA.
As the application developers develop APP, they must coordinate their development efforts in order to integrate the application software modules. Such coordination includes communicating, to the developers of MAIN, the references to each of the APP modules and their locations at runtime. Only when this information is received, the developers of MAIN can program MAIN. The developed code includes, for the purpose of running and executing the APP modules, instructions referencing each of the APP modules.
Typically, applications are developed in cycles, each new cycle producing a new version of the application that enhances features provided by previous versions. For example, each new version of the application includes a version of APP. The new version may incorporate a different set of APP modules, or versions of APP modules.
To ensure that the software modules operate together as an integrated unit, each version may undergo integration testing. Application integration testing entails installing software modules that form an application as a integrated unit on a computer system. The application is run and subjected to various test input or data. As tests are performed, errors are found, corrections are made, and the application is reformed and installed as an integrated unit on a computer system for further integration testing.
As the quantity of APP modules increases, application integration between developers becomes more complex and burdensome to the developers. In addition, numerous versions of the application add further to the complexity and burden of application integration.
One approach to managing the complexity and burden of application integration is the configuration management approach. Under the configuration management approach, personnel are dedicated to application integration. The staff may use software tools (xe2x80x9cconfiguration toolsxe2x80x9d), that assist in the configuration process and manage application integration. Configuration tools may include mechanisms for tracking the dependencies of a particular version of an application, for example, what APP modules MAIN invokes and what directory to store the APP modules. Configuration tools may also include a mechanism for determining whether a particular set of software modules satisfies the dependencies of a particular version of an application, for example, whether a set of modules includes a particular version of APP and a particular version of a set of APP modules, and whether the APP modules reside at the appropriate location.
Once a version of an application is tested, it is typically installed on multiple computer systems, such as computer systems used for testing and the computer systems operated by end users. Typically during application integration testing, configuration tools are used to automatically form an application so that it may tested by testers.
The process of installing an application on another computer system operated by an end user is referred to as deployment. Deployment involves verifying that various application dependencies are met once a version of an application is installed at a site. For example, deployment of a particular version of APP may involve, verifying that a particular site has the proper version of MAIN and the proper version of the APP modules. Deployment of an application becomes more burdensome as the dependencies of an application increase.
One approach for deployment is the installation module approach. Under the installation module approach, a software module runs at a site. The software module automatically ensures that the application dependencies have been met on the computer system on which the application is being installed and installs the software modules that form the application. Typically, configuration management personnel develop the installation modules, using configuration tools to at least partially automate the development of the installation module.
While the configuration management approach facilitates application integration, integration testing, and deployment, the configuration management approach is time-consuming and expensive. The approach requires dedication of significant resources in the form of software, computer systems, and personnel. Often, the duties of the configuration management personnel require that they possess software expertise, further increasing the cost of personnel qualified to perform configuration management tasks.
In addition, while the configuration management approach reduces the amount of work that developers of software modules expend in the task of application integration, the developers"" participation in application integration not eliminated. The developers may have to communicate the dependencies of their software modules to configuration management personnel. To address dependencies that may only be resolved by programming particular software modules in a particular manner, developers coordinate their efforts, deciding how software modules depend on each other and communicating these dependencies. For example, the developers of an APP module may have to communicate, to the developers of MAIN, the runtime location and reference to use to load and run the APP module. Furthermore, the configuration test does not eliminate the need to perform application integration testing.
Based on the foregoing, it is clearly desirable to provide a mechanism that reduces the dependencies between software modules of an application. In particular, there is a clear need to reduce the amount of application integration testing. There is also a need to reduce the requirement to explicitly reference the software modules in order to load and run the software modules of an application.
A method and mechanism for automatically integrating and executing application software modules is described. According to an aspect of the present invention, an application selects those software modules from a pool of software modules that match a particular criteria. For example, selection criteria may be that a software module be stored in files with file names that match a pre-defined character pattern.
According to another aspect of the present invention, if the software module is configured so that it may be run by the application, then the application runs the software module. A software module invokes an application-supplied function that provides an output buffer. The software module may generate HTML code and store the code in the output buffer.